home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / misc / unix / dcalc1_2_c.Z / dcalc1_2_c
Encoding:
Text File  |  1994-01-11  |  19.9 KB  |  708 lines
  1. /* dcalc v1.1 -- fits files onto disks */
  2. /* written 23 Dec 1993 by Mark Baker */
  3. /* modified 6 Jan 1994 by Mark Baker (Bugfix, added extra features) */
  4. /* modified 11 Jan 94 by Mark Baker (more bugs fixed) */
  5. /* This source code may be freely distributed and modified,
  6.    but may not be used in a commercial product without the author's
  7.    permission.  A small charge for media and copying is allowed ( $6 max ). */
  8. /* For usage, type dcalc -help when compiled. 
  9.    This should be simple ANSI C.  It calls the unix utilities
  10.    ls, rm and mv.  You will have to alter the source if your system
  11.    uses different commands.  Just alter the defines below.. */
  12.    
  13. #define    SYS_LIST    "ls -l"
  14. #define    SYS_DELETE    "rm"
  15. #define SYS_RENAME    "mv"
  16.  
  17. /* includes */
  18. #include    <stdio.h>
  19. #include    <stdlib.h>
  20. #include    <string.h>
  21. #include    <ctype.h> 
  22.  
  23. /* defines */
  24. enum {FALSE, TRUE};
  25. #define    ONE_K    1024L
  26. #define IBM_DD    720L * ONE_K
  27. #define IBM_HD    1440L * ONE_K
  28. #define DEF_SIZE IBM_DD
  29. #define Lnext(ptr)    ptr = ptr->next
  30.  
  31. /* structures and typedefs */
  32. struct    ilist            /* include list type */
  33. {
  34.     char    *pattern;    /* pattern to include */
  35.     struct ilist    *next;    /* next */
  36. };
  37.  
  38. struct    elist            /* exclude list type */
  39. {
  40.     char    *pattern;    /* pattern to exclude */
  41.     struct elist    *next;    /* next */
  42. };
  43.  
  44. struct    plist            /* path list type */
  45. {
  46.     char    *path;        /* path */
  47.     struct plist    *next;    /* next */
  48. };
  49.  
  50. struct    flist            /* file list type */
  51. {
  52.     char    *name;        /* file name */
  53.     char    *path;        /* path */
  54.     long    size;        /* size in bytes */
  55.     struct flist    *next;    /* next */
  56. };
  57.  
  58. struct    opt            /* options list type */
  59. {
  60.     long    disk_size;    /* size of disks, in bytes */
  61.     long    reserved;    /* size in bytes reserved for system */
  62.     int    output_to_file;    /* flag - send output to file */
  63.     int    include_list;    /* flag - use include list */
  64.     int    exclude_list;    /* flag - use exclude list */
  65.     int    rename_files;    /* flag - rename files */
  66.     int    backup;        /* flag - use BACKUP mode */
  67.     char    *output_filename;    /* file to output to */
  68.     struct ilist    *inc_list;    /* include list */
  69.     struct elist    *exc_list;    /* exclude list */
  70.     struct plist    *path_list;    /* path list */
  71. };    
  72.  
  73. struct    disklist        /* disk list type */
  74. {
  75.     struct flist    *files;    /* list of files on disk */
  76.     long    free_space;    /* free space left */
  77.     long    used_space;    /* space used on disk */
  78.     float    perc_used;    /* space used as a % */
  79.     int    number;        /* number of the disk */
  80.     struct disklist    *next;    /* next */
  81. };
  82.  
  83. /* function prototypes */
  84. int    main(int argc, char *argv[]);
  85. void    get_options(int argc, char *argv[]);
  86. struct flist    *get_files(void);
  87. struct disklist    *fit_files(struct flist *file_list_top);
  88. void    show_results(struct disklist *disk_list_top);
  89.  
  90. /* global variables */
  91. struct opt    options;    /* option list */
  92.  
  93. /* calculator program to add up size of files to fit on IBM disks */
  94. int    main(int argc, char *argv[])
  95. {
  96.     struct flist    *file_list;
  97.     struct disklist    *disk_list;
  98.     
  99.     /* get options from command line */
  100.     get_options(argc, argv);
  101.     
  102.     /* load in filenames */
  103.     file_list = get_files();
  104.     
  105.     /* fit files onto disk */
  106.     disk_list = fit_files(file_list);
  107.     
  108.     /* output results */
  109.     show_results(disk_list);
  110.     
  111.     return(0);
  112. }
  113.  
  114. int    str_match(char *src, char *match);
  115.  
  116. void    get_options(int argc, char *argv[])
  117. {
  118.     int    count, show_usage = FALSE;
  119.     long    num = 0;
  120.     float    ftmp;
  121.     char    *opt, *c;
  122.     struct plist    *cur_path;
  123.     struct elist    *cur_excl;
  124.     struct ilist    *cur_incl;
  125.     
  126.     /* clear options */
  127.     options.disk_size = 0;
  128.     options.output_to_file = FALSE;
  129.     options.include_list = FALSE;
  130.     options.exclude_list = TRUE;
  131.     options.rename_files = FALSE;
  132.     options.backup = FALSE;
  133.     options.output_filename = NULL;
  134.     options.inc_list = NULL;
  135.     options.exc_list = (struct elist *)malloc(sizeof(struct elist));
  136.     options.path_list = NULL;
  137.     options.reserved = -1;
  138.     
  139.     cur_excl = options.exc_list;
  140.     cur_excl->pattern = "dcalc.tmp";
  141.     cur_excl->next = NULL;
  142.     
  143.     for (count = 1; count < argc; ) 
  144.       if (argv[count][0] == '-') 
  145.       {
  146.          /* an option */
  147.          opt = argv[count] + 1;
  148.          count++;
  149.          /* flags */
  150.          if (str_match(opt,"?"))
  151.          {
  152.               show_usage = TRUE;
  153.          }
  154.          else if (str_match(opt,"hd"))
  155.          {
  156.               options.disk_size = IBM_HD ;
  157.          }
  158.          else if (str_match(opt,"dd"))
  159.          {
  160.               options.disk_size = IBM_DD ;
  161.          }
  162.          else if (str_match(opt,"help"))
  163.          {
  164.                show_usage = TRUE;
  165.          }
  166.          else if (str_match(opt,"rename"))
  167.          {
  168.               options.rename_files = TRUE;
  169.          }
  170.          else if (str_match(opt,"backup"))
  171.          {
  172.               options.backup = TRUE;
  173.               options.rename_files = FALSE;
  174.          }
  175.          if ((count < argc) && (argv[count][0] != '-'))
  176.          {
  177.             if (str_match(opt,"s"))
  178.             {
  179.                for (c = argv[count] ; *(c+1) != '\0' ; c++) ;
  180.                if (toupper(*c) == 'K') 
  181.                {
  182.                  *c == '\0';
  183.                  if (sscanf(argv[count],"%d", &num)) 
  184.                  {
  185.                      options.disk_size = num * ONE_K;
  186.                      count++;
  187.                  }    
  188.                }
  189.                else if (toupper(*c) == 'M')
  190.                {
  191.                  *c == '\0';
  192.                  if (sscanf(argv[count],"%f", &ftmp))
  193.                  {
  194.                      options.disk_size = (long) (ftmp * (float)(ONE_K * ONE_K));
  195.                      count++;
  196.                  }
  197.                }
  198.                else if (sscanf(argv[count],"%d", &num))
  199.                 {
  200.                  options.disk_size = num;
  201.                  count++;
  202.                 }
  203.             }
  204.             else if (str_match(opt,"o"))
  205.             {
  206.                  options.output_to_file = TRUE;
  207.                  options.output_filename = argv[count];
  208.                  count++;
  209.              }
  210.             else if (str_match(opt,"ls"))
  211.             {
  212.                 /* add another path */
  213.                  if (options.path_list == NULL)
  214.                  {
  215.                      options.path_list = (struct plist *)malloc(sizeof(struct plist));
  216.                      cur_path = options.path_list;
  217.                  }
  218.                  else
  219.                  {
  220.                      cur_path->next = (struct plist *)malloc(sizeof(struct plist));
  221.                      Lnext(cur_path);
  222.                  }
  223.                  cur_path->path = argv[count];
  224.                  cur_path->next = NULL;
  225.             count++;
  226.             }
  227.             else if (str_match(opt,"in"))
  228.             {
  229.                 /* add to include list */
  230.                while((count < argc) && (argv[count][0] != '-')) 
  231.                {
  232.                    if (options.inc_list == NULL)
  233.                    {
  234.                     options.inc_list = (struct ilist *)malloc(sizeof(struct ilist));
  235.                      options.include_list = TRUE;
  236.                         cur_incl = options.inc_list;
  237.                     }
  238.                     else
  239.                     {
  240.                      cur_incl->next = (struct ilist *)malloc(sizeof(struct ilist));
  241.                      Lnext(cur_incl);
  242.                     }
  243.                     cur_incl->pattern = argv[count];
  244.                     cur_incl->next = NULL;
  245.                count++;
  246.             }    
  247.             }
  248.             else if (str_match(opt,"ex"))
  249.             {
  250.                 /* add to exclude list */
  251.                 while((count < argc) && (argv[count][0] != '-')) 
  252.                {
  253.                     cur_excl->next = (struct elist *)malloc(sizeof(struct elist));
  254.                     Lnext(cur_excl);
  255.                     cur_excl->pattern = argv[count];
  256.                     cur_excl->next = NULL;
  257.                count++;
  258.             }
  259.             }
  260.             else if (str_match(opt,"reserve"))
  261.             {
  262.                for (c = argv[count] ; *(c+1) != '\0' ; c++) ;
  263.                if (toupper(*c) == 'K') 
  264.                {
  265.                  *c == '\0';
  266.                  if (sscanf(argv[count],"%d", &num)) 
  267.                  {
  268.                      options.reserved = num * ONE_K;
  269.                      count++;
  270.                  }    
  271.                }
  272.                else if (toupper(*c) == 'M')
  273.                {
  274.                  *c == '\0';
  275.                  if (sscanf(argv[count],"%f", &ftmp))
  276.                  {
  277.                      options.reserved = (long) (ftmp * (float)(ONE_K * ONE_K));
  278.                      count++;
  279.                  }
  280.                }
  281.                else if (toupper(*c) == 'P')
  282.                {
  283.                  *c == '\0';
  284.                  if (options.disk_size == 0) options.disk_size = IBM_DD;
  285.                  if (sscanf(argv[count],"%f",&ftmp))
  286.                  {
  287.                 options.reserved = (long)(ftmp * (float)(options.disk_size));
  288.                 count++;
  289.                  }
  290.                }
  291.                else if (sscanf(argv[count],"%d", &num))
  292.                 {
  293.                  options.reserved = num;
  294.                  count++;
  295.                 }
  296.             }
  297.          }
  298.       }
  299.       else
  300.       {
  301.          /* not an option.. must be path */
  302.          /* add to path list */
  303.          if (options.path_list == NULL)
  304.          {
  305.              options.path_list = (struct plist *)malloc(sizeof(struct plist));
  306.              cur_path = options.path_list;
  307.          }
  308.          else
  309.          {
  310.              cur_path->next = (struct plist *)malloc(sizeof(struct plist));
  311.              Lnext(cur_path);
  312.          }
  313.          cur_path->path = argv[count];
  314.          cur_path->next = NULL;
  315.          count++;
  316.       }
  317.     /* now put in defaults */
  318.     if (options.disk_size == 0) options.disk_size = IBM_DD ;
  319.     if (options.reserved == -1) options.reserved = options.disk_size / 100;
  320.     if (options.reserved >= options.disk_size)
  321.     {
  322.         printf("Error: cannot reserve more space than disk size!\n");
  323.         exit(1);
  324.     }
  325.     if (show_usage)
  326.     {
  327.         /* print the usage */
  328.         printf("Usage:  dcalc [ path ... ] [ option ... ]\n");
  329.         printf(" path = path to scan for files\n");
  330.         printf(" option is one of the following:\n");
  331.         printf("   -hd = fit onto IBM 1.44MB high density disks\n");
  332.         printf("   -dd = fit onto IBM 720K disks (default)\n");
  333.         printf("   -s NNN = fit onto disk of size NNN\n");
  334.         printf("   -reserve NNN = reserve NNN of the disk for filesystem, etc.\n");
  335.         printf("             (default is 1%% to be safer)\n");
  336.         printf("   -o file = send output to file\n");
  337.         printf("   -ls path ... = add more paths\n");
  338.         printf("   -in \"pat\" = include files matching pattern (* ? wild)\n");
  339.         printf("   -ex \"pat\" = exclude files matching pattern\n"); 
  340.         printf("   -rename = rename files for easy copying (A_file1 B_file2 ...) \n");
  341.         printf("   -backup = use MSDOS backup mode, fit files across disks\n");
  342.         printf("  NNN is I  for I     bytes (  400 ==     400 bytes)\n");
  343.         printf("         Ik for I kilobytes (   1k ==    1024 bytes)\n");
  344.         printf("         Fm for F megabytes ( 1.4m == 1048576 bytes)\n");
  345.         printf("         Fp for F %% of disk space (cannot be used with -s)\n");
  346.         printf(" I is any integer (whole number), F any float (real number)\n");  
  347.     }
  348. }
  349.  
  350. int    pattern_match(char *str, char *pat);
  351. struct flist    *read_file_data_from_directory(char *path, 
  352.         struct flist *file_next);
  353.  
  354. struct flist    *get_files(void)
  355. {
  356.     /* load in files from directories specified in path_list */
  357.     struct plist    *path_ptr=NULL;
  358.     struct flist    *file_list_top;
  359.     
  360.     if (options.path_list != NULL)
  361.     {
  362.       for (path_ptr = options.path_list; path_ptr != NULL; Lnext(path_ptr))
  363.       {
  364.         file_list_top = read_file_data_from_directory(path_ptr->path,
  365.           file_list_top);
  366.       }
  367.     }
  368.     else
  369.     {
  370.     /* default, scan current directory only */
  371.       file_list_top = read_file_data_from_directory("",file_list_top);
  372.     }
  373.     
  374.     return(file_list_top);
  375. }
  376.  
  377. struct flist    *read_file_data_from_directory(char *path, 
  378.         struct flist *file_top)
  379. { 
  380.     /* read in and append file data to list */
  381.     char     temp[200],line[100];
  382.     char    *path_name, *c;
  383.     FILE    *fptr;
  384.     char    perm[10], dum[20], name[50];
  385.     struct ilist    *inc_ptr;
  386.     struct elist    *exc_ptr;
  387.     struct flist    *file;
  388.     long    size = 0;
  389.     int    num,match;
  390.     
  391.     path_name = (char *) malloc (strlen(path)+1);
  392.     strcpy(path_name, path);
  393.     sprintf(temp,"%s %s > dcalc.tmp", SYS_LIST, path);
  394.     system(temp);
  395.     fptr = fopen("dcalc.tmp","r");
  396.     if (fptr == NULL)
  397.     {
  398.       printf("Error opening dcalc.tmp\n");
  399.       exit(1);
  400.     }
  401.     /* you might have to change this next bit if the format of your
  402.      directory listing differs from the standard "ls -l" command */ 
  403.     while(fgets(line,100,fptr))
  404.     {
  405.       num = sscanf(line,"%s%s%s%s%d%s%s%s%s",perm,dum,dum,dum,&size,
  406.           dum,dum,dum,name);
  407.       if (num == 9)            /* removes "total nn" + other stuff */
  408.        if (perm[0] == '-')        /* files only, not directory etc.. */
  409.        {
  410.            /* if ls -F has been used, file name may end in special chars 
  411.              '/' directory and '@' link are screened out above, but '*'
  412.              must be removed from the file name, or errors will occur */
  413.            for (c = name; *c != '\0'; c++) if (*c == '*') *c == '\0';
  414.            /* apply filters.. ? means match any 1 char
  415.              * means match any chars up to . */
  416.            if (options.include_list)
  417.            {
  418.              /* include filter */
  419.           match = FALSE;
  420.              for (inc_ptr = options.inc_list; 
  421.                   inc_ptr != NULL; Lnext(inc_ptr)) 
  422.               if (pattern_match(name,inc_ptr->pattern))
  423.               {
  424.                 match = TRUE;
  425.                   break;
  426.               }
  427.           if (match == FALSE) size = -1;
  428.            }
  429.         if ((options.exclude_list) && (size >= 0))
  430.         {
  431.           /* exclude filter */
  432.           for (exc_ptr = options.exc_list;
  433.                exc_ptr != NULL; Lnext(exc_ptr)) 
  434.               if (pattern_match(name,exc_ptr->pattern) == TRUE) 
  435.               {
  436.                   size = -1;
  437.                   break;
  438.               }
  439.         }
  440.         if (size >= 0)    /* filters set size = -1 if reject */
  441.         {
  442.           if (file_top == NULL)
  443.           {
  444.               file_top = (struct flist *)malloc(sizeof(struct flist));
  445.               file = file_top;
  446.           }
  447.           else
  448.           {
  449.               file->next = (struct flist *)malloc(sizeof(struct flist));
  450.               Lnext(file);
  451.           }
  452.           file->name = (char *)malloc(strlen(name)+2);
  453.           strcpy(file->name,name);
  454.           file->size = size;
  455.           file->path = path_name;
  456.           file->next = NULL;
  457.         }
  458.        }
  459.     }
  460.     sprintf(name, "%s dcalc.tmp", SYS_DELETE);
  461.     system(name);        /* remove the temporary file */
  462.     return(file_top);
  463. }
  464.  
  465. struct disklist    *fit_files(struct flist *file_list_top)
  466. {
  467.     /* fit files onto as few disks as possible */
  468.     struct flist    *file, *biggest, *first_file = NULL, *top, *disk_file;
  469.     struct disklist    *disk, *first_disk = NULL, *tdisk;
  470.     int    num_to_place = 0;
  471.     long    space = 0, num_disks = 0;
  472.     long    disk_space = 0;
  473.     struct flist    *null_file;
  474.     
  475.     null_file = (struct flist *) malloc (sizeof(struct flist));
  476.     null_file->next = NULL;
  477.     null_file->name = NULL;
  478.     null_file->size = 0;
  479.     null_file->path = NULL;
  480.     
  481.     top = file_list_top;
  482.     disk_space = options.disk_size - options.reserved;
  483.     
  484.     if (options.backup) 
  485.     {
  486.         /* split files across discs */
  487.         space = 0;
  488.         for(file = top; file != NULL; Lnext(file) )
  489.             space += file->size;
  490.         num_disks = (space / disk_space) + 1;
  491.         space -= (num_disks - 1) * disk_space;
  492.         first_disk = (struct disklist *)malloc(sizeof(struct disklist));
  493.         disk = first_disk;
  494.         disk->free_space = options.disk_size - space;
  495.         disk->used_space = space;
  496.         disk->perc_used = (float)100 * (float)disk->used_space / (float)options.disk_size;
  497.     disk->next = NULL;
  498.     disk->files = top;
  499.     disk->number = (int)num_disks;
  500.     }
  501.     else
  502.     {
  503.         /* check that a file is not bigger than disk space */
  504.         for(file = top; file != NULL; Lnext(file), num_to_place++ )
  505.             if (file->size > disk_space)
  506.             {
  507.                 printf("File \"%s\" will not fit onto a single disk!\n", file->name);
  508.                 printf("Use -backup mode to split across disks\n");
  509.                 exit(1);
  510.             }
  511.     while(num_to_place-- > 0)
  512.     {
  513.       /* find biggest file that will fit in remaining space */
  514.       biggest = null_file;
  515.       while (biggest == null_file)
  516.       {
  517.         for (file = top; file != NULL; Lnext(file) )
  518.           if ((file->size <= space) && (file->size > biggest->size))
  519.               biggest = file;
  520.         if (biggest == null_file)
  521.         {
  522.           /* no more files will fit onto current disk, start a new one */
  523.           if (first_disk == NULL)
  524.           {
  525.               first_disk = (struct disklist *)malloc(sizeof(struct disklist));
  526.               disk = first_disk;
  527.           }
  528.           else
  529.           {
  530.               disk->used_space = disk_space - space;
  531.               disk->free_space = options.disk_size - disk->used_space;
  532.               disk->perc_used = (float)100.0 * (float)disk->used_space / (float)options.disk_size;
  533.               disk->files = first_file;
  534.               disk->next = (struct disklist *)malloc(sizeof(struct disklist));
  535.               Lnext(disk);
  536.               disk->number = (int)++num_disks;
  537.               disk->next = NULL;
  538.           }
  539.           first_file = NULL;
  540.           space = disk_space;
  541.         }
  542.       }
  543.       /* have found biggest file that fits on disk... move it onto disk */
  544.       if (first_file == NULL) 
  545.       {
  546.           first_file = biggest;
  547.           disk_file = biggest;
  548.       }
  549.       else
  550.       {
  551.           disk_file->next = biggest;
  552.           Lnext(disk_file);
  553.       }
  554.       /* unlink from list */
  555.       if (biggest == top)
  556.           top = biggest->next;
  557.       else {
  558.           for (file = top; file->next != biggest; Lnext(file)) ;
  559.           file->next = biggest->next;    
  560.       }
  561.       space -= disk_file->size;
  562.       disk_file->next = NULL;
  563.     }
  564.     if (space < options.disk_size) 
  565.     {
  566.       disk->used_space = disk_space - space;
  567.       disk->free_space = options.disk_size - disk->free_space;
  568.       disk->perc_used = (float)100.0 * (float)disk->used_space / (float)options.disk_size;
  569.       disk->files = first_file;
  570.       disk->number = (int)num_disks++;
  571.       disk->next = NULL;
  572.     }
  573.     else
  574.     {
  575.       for (tdisk = first_disk; tdisk->next != disk; Lnext(tdisk) ) ;
  576.       tdisk->next = NULL;
  577.       free(disk);
  578.     }
  579.     }
  580.     free(null_file);
  581.     return(first_disk);
  582. }
  583.  
  584. void    show_results(struct disklist *disk_list_top)
  585. {
  586.     /* show results.. */
  587.     struct disklist    *disk;
  588.     struct flist    *file;
  589.     char    disk_letter;
  590.     char    temp[100], temp2[100];
  591.     
  592.     printf(" Disk size is %d bytes, %d bytes reserved for system\n", 
  593.         options.disk_size, options.reserved); 
  594.     if (options.backup)
  595.     {
  596.       disk = disk_list_top;
  597.       printf("The backup takes up %d disk%c\n",disk->number,
  598.        (disk->number > 1 ? 's' : ' ') );
  599.       printf("The last disk is %.2f%% full ( %d used, %d free )\n",
  600.        disk->perc_used, disk->used_space, disk->free_space);
  601.       printf("Listing of files in backup:\n");
  602.       for(file = disk->files; file != NULL; Lnext(file) )
  603.          printf(" %s\n", file->name);
  604.     }
  605.     else if (options.rename_files)
  606.     {
  607.       printf("Files as split onto disks:\n");
  608.       for (disk = disk_list_top; disk != NULL; Lnext(disk) )
  609.       {
  610.          disk_letter = (char)('A' + disk->number);
  611.          printf("++ Disk %c ++ %d used, %d free, disk %.2f%% full ++\n",
  612.            disk_letter, disk->used_space, disk->free_space, 
  613.            disk->perc_used);
  614.          for(file = disk->files; file != NULL; Lnext(file) )
  615.          {
  616.              if (file->name[1] == '_')
  617.                  if (file->name[0] == disk_letter)  
  618.                  sprintf(temp,"%s",file->name);
  619.                  else
  620.                      sprintf(temp,"%c%s", disk_letter, (file->name + 1));
  621.              else
  622.                  sprintf(temp,"%c_%s", disk_letter, file->name);
  623.              printf(" %s >>> \t%s\n", file->name, temp);
  624.          } 
  625.       }
  626.       printf("Rename files? (y/n) : ");
  627.       scanf("%s",temp);
  628.       if (temp[0] == 'y')
  629.       {
  630.          for (disk = disk_list_top; disk != NULL; Lnext(disk) )
  631.          {
  632.            disk_letter = (char)('A' + disk->number);
  633.            for(file = disk->files; file != NULL; Lnext(file) )
  634.            {
  635.                  if (file->name[1] == '_')
  636.                      if (file->name[0] == disk_letter)
  637.                        sprintf(temp2,"%s",file->name);
  638.                      else
  639.                        sprintf(temp2,"%c%s",disk_letter, (file->name + 1));
  640.                  else
  641.                      sprintf(temp2,"%c_%s", disk_letter, file->name);
  642.           if (file->path[0] != '\0')
  643.            sprintf(temp,"%s %s/%s %s/%s", SYS_RENAME,
  644.             file->path, file->name,
  645.             file->path, temp2);
  646.               else
  647.                sprintf(temp,"%s %s %s", SYS_RENAME, file->name, temp2);
  648.           if ((file->name[0] == temp2[0]) && (file->name[1] == temp2[1]))
  649.               /* no change */ ;
  650.           else
  651.                   system(temp);
  652.               /*printf("%s\n",temp);*/
  653.            } 
  654.          }
  655.       }
  656.     }
  657.     else
  658.     {
  659.       printf("Files as split onto disks:\n");
  660.       for (disk = disk_list_top; disk != NULL; Lnext(disk) )
  661.        {
  662.          printf("++ Disk %c ++  %d used, %d free, disk %.2f%% full ++\n",
  663.           (char)('A' + disk->number), disk->used_space, disk->free_space, 
  664.            disk->perc_used);
  665.          for(file = disk->files; file != NULL; Lnext(file) )
  666.          {
  667.            printf(" %s\n", file->name);
  668.          }
  669.       }
  670.     }
  671. }
  672.  
  673. int    str_match(char *src, char *match)
  674. {
  675.     if (strlen(src) != strlen(match)) return(FALSE);
  676.     while (*src != '\0')
  677.     {
  678.       if (*src != *match) return(FALSE);
  679.       src++;
  680.       match++;
  681.     }
  682.     return(TRUE);
  683. }
  684.  
  685. int    pattern_match(char *str, char *pat)
  686. {
  687.     /* return TRUE if str matches pat */
  688.     for (;(*pat != '\0') && (*str != '\0'); pat++, str++)
  689.     {
  690.       if (*pat == '?') ;    /* dont try and match this one */
  691.       else if (*pat == '*')    /* search for char - after this one */
  692.       {
  693.         pat++;
  694.         if (*pat == '\0') return(TRUE);    /* '*' at end means don't match rest */ 
  695.         /* search for *pat */
  696.         while (*str != *pat)
  697.         {
  698.             if (*str == '\0') return(FALSE); /* ended with some left to match */
  699.             str++;
  700.         }
  701.       }
  702.       else     /* match normally */
  703.         if (*pat != *str) return(FALSE);
  704.     } 
  705.     if (*pat != *str) return(FALSE);    /* must end together */
  706.     return(TRUE);
  707. }
  708.